#include "lock_uart.h"
#include "string.h"
#include "nfc_ctrl.h"
#include "adc2_rte.h"
#include "app_ehbl_uart.h"
#include "ver_comp.h"
#include "lock_loop.h"
Rt_result EHBL_quit_eol(void);
void Whether_test_EOL(void);
typedef struct
{
    Rt_result (*EHBL_test)(void);
} AppServer_E_Fun;
static union DataUnion data;
Rt_result EHBL_Telescoping(void);
Rt_result EHBL_Communications_Test(void);
Rt_result EHBL_Input_Test(void);
Rt_result EHBL_Lock_test(void);
Rt_result EHBL_UnLock_test(void);
Rt_result EHBL_No_Lock_Test(void);
static EHBL_test EH_test;

static AppServer_E_Fun Ehbl_List[EHBL_MAX] =
    {
        {EHBL_Communications_Test},
        {EHBL_UnLock_test},
        {EHBL_Telescoping},
        {EHBL_Input_Test},
        {EHBL_Lock_test},
        {EHBL_No_Lock_Test},
        {loop_initunlock},
        {loop_unlock_lock},
        {EHBL_quit_eol}};

/*
 * 函数介绍: 方向锁相关初始化
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void ehbl_init(void)
{
    uint8_t i;
    EH_test.E_st = EHBL_MAX;
    for (i = 0; i < EHBL_MAX; i++)
    {
        EH_test.e_sta[i] = TEST_FAIL;
    }
    EH_test.locked = IS_LOCK;
    EH_test.TELES_num = 0;
    EH_test.EHBL_ver_comp = TEST_OK;
    EH_test.EHBL_results = TEST_WAIT;    /*方向锁测试步骤6-10是否流程走完*/
    EH_test.EHBL_Eol = TEST_WAIT;        /*EHBL退出EOL模式是否需要执行*/
    EH_test.Sflag = NO_SENT_OR_RECEIVED; /*Test_Fixture请求帧串口发送标志*/
    EH_test.Rflag = NO_SENT_OR_RECEIVED; /*EHBL应答帧串口接受标志*/

    EH_test.E_flag.v_stage = HARDWARE_VERSION;      /*软硬件阶段*/
    EH_test.E_flag.Error_record = 0;                /*硬件软件错误计数*/
    EH_test.E_flag.EHBL_send_data_only = false;     /*EHBL通讯测试软硬件版本号,只发送一次请求标志位*/
    EH_test.E_flag.I_stage = INPUT_VERSION;         /*EHBL输入测试,输入和上锁禁止阶段*/
    EH_test.E_flag.L_stage = LOCK_OR_UNLOCK_STAGE;  /*闭锁、标定阶段*/
    EH_test.E_flag.Unlock_first = 0;                /*EHBL禁止上锁前先将锁复位到解锁状态*/
    EH_test.E_flag.UL_stage = LOCK_OR_UNLOCK_STAGE; /*EHBL解锁标定测试,解锁、标定阶段*/
}

/*
 * 函数介绍: 方向锁串口接受回调函数
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void Ehbl_uart_cbk(uint16_t cmd, uint8_t data[])
{
    if (EH_test.Ehbl_resp.sig.CMD == cmd && OK_SENT_OR_RECEIVED == EH_test.Sflag)
    {
        EH_test.Sflag = NO_SENT_OR_RECEIVED; /*清除各阶段串口发送成功标志*/
        EH_test.Rflag = OK_SENT_OR_RECEIVED; /*写入各阶段串口接受成功标志*/
        EH_test.Ehbl_resp.sig.CMD = cmd;
        memcpy(&EH_test.Ehbl_resp.L_data[0], &data[0], 4);
    }
    else
    {
    }
}

/**
 * 判断锁的状态
 *
 * 本函数用于返回当前实际的锁状态。
 * @return 返回实际的锁状态，是一个枚举类型，表示锁当前实际是锁定还是未锁定。
 * 锁舌传感器的工作原理是：len = k*v + b，其中len为方向锁伸出的距离，v为锁舌传感器的电压值，
 * k为斜率，b为截距。通过给定的两个点的len和v值可以计算出k和b。
 * 本函数首先读取锁舌传感器的电压值，然后根据预设的公式计算锁伸出的距离，
 * 并根据计算得到的距离判断锁的状态（已上锁、未上锁或等待状态）。
 */
Rt_result Lock_tongue_judgment(Is_locked Is_l_exp)
{
    Rt_result result = TEST_WAIT;                              /*返回值*/
    Is_locked Is_l = IS_WAIT;                                  /* 实际锁状态初始化为等待状态 */
    float lock_len = 0;                                        /* 锁舌伸出的距离 */
    float wance_ad = 0;                                        /* 传感器的电压值 */
    wance_ad = RTE_ADC2_CHANNEL_V(PA7_ADC2_INP7);              /* 5v传感器电压值 */
    lock_len = (wance_ad - 0) / 5 * 70 - 35 - LOCK_TONE_PITCH; /* 根据传感器电压计算锁舌伸出距离 */
    if (IS_UNLOCK == Is_l_exp)
    {
        lock_len = lock_len - 0.2f;
    }
    /* 根据计算得到的锁舌伸出距离判断锁的状态 */
    if (lock_len >= LOCK_EXT_MIN && lock_len <= LOCK_EXT_MAX)
    {
        Is_l = IS_LOCK; /* 如果伸出距离符合上锁范围，则判断为已上锁 */
    }
    else if (lock_len >= LOCK_NOT_EXT_MIN && lock_len <= LOCK_NOT_EXT_MAX)
    {
        Is_l = IS_UNLOCK; /* 如果伸出距离符合未上锁范围，则判断为未上锁 */
    }

    if (Is_l == Is_l_exp)
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }

    return result;
}

/*
 * 函数介绍: 修改EHBL测试阶段
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void Modify_EHBL_testing_phase(EHBL_stage phase)
{
    EH_test.E_st = phase;
}

/*
 * 函数介绍: 获取EHBL测试阶段
 * 参数:
 * 返回值: {*}
 * 备注:
 */
EHBL_stage Get_EHBL_testing_phase(void)
{
    return EH_test.E_st;
}

/*
 * 函数介绍: EHBL_CMD_DATA检测
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result Version_number_detection(uint16_t cmd, uint32_t VERSION)
{
    Rt_result result = TEST_WAIT;
    /*清除接受标志*/
    EH_test.Rflag = NO_SENT_OR_RECEIVED;
    if (QUERY_CMD == cmd)
    {
        EH_test.Ehbl_resp.sig.DATA = EH_test.Ehbl_resp.sig.DATA & 0x0000FFFF;
    }
    /*检测传入与串口收到的是否一致*/
    if (cmd == EH_test.Ehbl_resp.sig.CMD && VERSION == EH_test.Ehbl_resp.sig.DATA)
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: EHBL通讯测试软硬件版本号
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_hard_soft_numtest(uint16_t Cmd, uint32_t Req_data)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*只发送一次闭锁请求*/
    if (false == EH_test.E_flag.EHBL_send_data_only)
    {
        EH_test.Ehbl_resp.sig.CMD = Cmd;
        EH_test.Test_Fixture.sig.CMD = Cmd;
        EH_test.Test_Fixture.sig.DATA = Req_data;
        EH_test.E_flag.EHBL_send_data_only = true;
        RTE_EHBL_UART_TRANSMIT(EH_test.Test_Fixture.sig.CMD, EH_test.Test_Fixture.sig.DATA); /*串口发送查询硬件版本请求*/
        EH_test.Sflag = OK_SENT_OR_RECEIVED;                                                 /*发送标志位置位*/
        EH_test.Rflag = NO_SENT_OR_RECEIVED;                                                 /*发送标志位置位*/
        Record_send_time = RTE_GET_TIMER();                                                  /*记录发送开始时间*/
    }
    /*串口接受到回复或者超时进入*/
    else if (OK_SENT_OR_RECEIVED == EH_test.Rflag || RTE_TIMEOUT_JUDGMENT(Record_send_time, LOCK_ACCEPT_MAX_DELMS))
    {
        /*接受到回复*/
        if (OK_SENT_OR_RECEIVED == EH_test.Rflag)
        {
            result = TEST_OK;
        }
        else
        {
            /*超时*/
            result = TEST_FAIL;
        }
        EH_test.E_flag.EHBL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: 方向锁串口通讯测试计算发送给LCD的软硬件版本号
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void lock_rtlcd_swhd(Byte0Status St, LCD_TestStatus data_type, NFCTestStatus Status, uint8_t candata[])
{
    uint8_t i;
    uint32_t ware_version; /*发送给LCD的硬件版本号*/
    reverse_array(candata, 4);
    memcpy(&data.bytes[0], candata, 4);
    if (STATUS_QUALIFIED == St)
    {
        // 将字节转换为ASCII字符并存储到字符串中
        for (i = 0; i < 4; i++)
        {
            data.bytes[i] = data.bytes[i] - '0';
        }
    }
    ware_version = data.value;
    RTE_UART7_LCD_SHOW(Status, data_type, ware_version); /*LCD通过CMD分别显示在软件版本位置上*/
    if (LCD_HARDWARE_VERSION == data_type)
    {
        data_type = HARDWARE_VERSION_NUMBER_CORRECT;
    }
    else if (LCD_SOFTWARE_VERSION == data_type)
    {
        data_type = SOFTWARE_VERSION_NUMBER_CORRECT;
    }
    EH_test.EHBL_ver_comp |= Version_number_comparison(Status, St, data_type, data.bytes);
}

Rt_result EHBL_Telescoping(void)
{
    Rt_result result = TEST_WAIT;         /*返回值*/
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    if (false == EH_test.E_flag.EHBL_send_data_only)
    {
        if (IS_LOCK == EH_test.locked)
        {
            RTE_UART7_LCD_SHOW(EHBL_TEST, EHBL_BREAKING, 0x00000000);
            EH_test.locked = IS_UNLOCK;
            RTE_EHBL_UART_TRANSMIT(LOCK_TEST_CMD, EHBL_LOCK_REQUEST_DATA); /* 进行闭锁 */
        }
        else if (IS_UNLOCK == EH_test.locked)
        {
            EH_test.locked = IS_LOCK;
            RTE_EHBL_UART_TRANSMIT(UNLOCK_TEST_CMD, EHBL_UNLOCK_REQUEST_DATA); /* 进行解锁 */
        }
        Record_send_time = RTE_GET_TIMER(); /*记录发送开始时间*/
        EH_test.E_flag.EHBL_send_data_only = true;
    }
    else if (RTE_TIMEOUT_JUDGMENT(Record_send_time, TELES_TEST_DELMS))
    {
        if (IS_LOCK == EH_test.locked)
        {
            EH_test.TELES_num++;
        }
        if (TELES_TEST_NUM <= EH_test.TELES_num)
        {
            result = TEST_OK;
            RTE_UART7_LCD_SHOW(EHBL_TEST, EHBL_BREAKING, 0x00000001);
        }
        /*重置*/
        EH_test.E_flag.EHBL_send_data_only = false;
    }
    return result;
}

/*
 * 函数介绍: EHBL通信测试版本号测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_Communications_Test(void)
{
    Rt_result result = TEST_WAIT;                   /*返回值*/
    uint8_t uartdata[4] = {0x00, 0x00, 0x00, 0x00}; /*uart软硬件失败版本号*/
    switch (EH_test.E_flag.v_stage)
    {
    case HARDWARE_VERSION: /*硬件版本阶段*/
        result = EHBL_hard_soft_numtest(HARDWARE_VERSION_CMD, EHBL_REQUEST_DATA);
        if (TEST_OK == result)
        {
            /*硬件版本测试通过，开始测试软件版本*/
            EH_test.E_flag.v_stage = SOFTWARE_VERSION;
            lock_rtlcd_swhd(STATUS_QUALIFIED, LCD_HARDWARE_VERSION, EHBL_TEST, EH_test.Ehbl_resp.L_data);
        }
        else if (TEST_FAIL == result)
        {
            /*硬件版本测试失败,记录错误，改测软件版本*/
            EH_test.E_flag.v_stage = SOFTWARE_VERSION;
            EH_test.E_flag.Error_record += 1;
            lock_rtlcd_swhd(STATUS_UNQUALIFIED, LCD_HARDWARE_VERSION, EHBL_TEST, uartdata);
        }
        else
        {
        }
        result = TEST_WAIT;
        break;
    case SOFTWARE_VERSION: /*软件版本阶段*/
        result = EHBL_hard_soft_numtest(SOFTWARE_VERSION_CMD, EHBL_REQUEST_DATA);
        if (TEST_OK == result)
        {
            /*软件版本测试通过，通信测试通过，恢复默认值硬件测试*/
            EH_test.E_flag.v_stage = HARDWARE_VERSION;
            if (0 < EH_test.E_flag.Error_record)
            {
                result = TEST_FAIL; /*硬件版本失败，通信测试失败*/
            }
            else
            {
                result = TEST_OK; /*通信测试成功*/
            }
            EH_test.E_flag.Error_record = 0; /*硬件软件错误计数清零*/
            lock_rtlcd_swhd(STATUS_QUALIFIED, LCD_SOFTWARE_VERSION, EHBL_TEST, EH_test.Ehbl_resp.L_data);
            HAL_Delay(100);
        }
        else if (TEST_FAIL == result)
        {
            /*软件版本测试失败*/
            EH_test.E_flag.v_stage = HARDWARE_VERSION;
            result = TEST_FAIL;
            EH_test.E_flag.Error_record = 0; /*硬件软件错误计数清零*/
            lock_rtlcd_swhd(STATUS_UNQUALIFIED, LCD_SOFTWARE_VERSION, EHBL_TEST, uartdata);
            HAL_Delay(100);
        }
        else
        {
        }
        break;
    }
    return result;
}

/*
 * 函数介绍: EHBL通用闭锁解锁检测函数
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_Req_Unlock(uint16_t Cmd, uint32_t Req_data, Is_locked Is_l)
{
    Rt_result result = TEST_WAIT;         /*返回值*/
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/

    /*循环检测，所以只发送一次请求*/
    if (false == EH_test.E_flag.EHBL_send_data_only)
    {
        EH_test.Test_Fixture.sig.CMD = Cmd;
        EH_test.Test_Fixture.sig.DATA = Req_data;
        EH_test.E_flag.EHBL_send_data_only = true;
        RTE_EHBL_UART_TRANSMIT(EH_test.Test_Fixture.sig.CMD, EH_test.Test_Fixture.sig.DATA); /*串口发送通用请求*/
        Record_send_time = RTE_GET_TIMER();                                                  /*记录发送开始时间*/
    }
    /*等待上锁1500MS超时进入*/
    else if (yes_timeout == RTE_TIMEOUT_JUDGMENT(Record_send_time, LOCK_WAIT_LOCKMS))
    {
        /*AD检测是否上锁，给Is_l赋值*/
        result = Lock_tongue_judgment(Is_l);
        /*重置*/
        EH_test.E_flag.EHBL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: EHBL输入测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_Input_Test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    switch (EH_test.E_flag.I_stage)
    {
    case INPUT_VERSION: /*输入阶段*/
        result = EHBL_universal_Req_Rsp(INPUT_TEST_CMD, INPUT_TEST_CMD, EHBL_REQUEST_DATA, EHBL_RSP_DATA_OK);
        if (TEST_OK == result)
        {
            /*输入测试通过，开始测试禁止上锁阶段*/
            EH_test.E_flag.I_stage = UNLOCK_VERSION;
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET); /*IGN-I-HL下电*/
            result = TEST_WAIT;
        }
        else if (TEST_FAIL == result)
        {
            /*输入失败，直接退出该阶段*/
            result = TEST_FAIL;
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET); /*IGN-I-HL下电*/
        }
        else
        {
        }
        break;
    case UNLOCK_VERSION: /*禁止上锁阶段*/
        /*产品是否上锁结果,未上锁即测试通过*/
        result = EHBL_Req_Unlock(LOCK_TEST_CMD, EHBL_REQUEST_DATA, IS_UNLOCK);
        break;
    default:
        break;
    }
    return result;
}

/*
 * 函数介绍: EHBL通用请求应答函数
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_universal_Req_Rsp(uint16_t ReqCmd, uint16_t RspCmd, uint32_t Req_data, uint32_t Rsp_data_ok)
{
    Rt_result result = TEST_WAIT;

    static uint32_t Record_send_time = 0; /*记录_发送_时间*/

    /*循环检测，所以只发送一次请求*/
    if (false == EH_test.E_flag.EHBL_send_data_only)
    {
        /*判断为输入测试和禁止上锁时进行IGN-I-HL上电*/
        if (INPUT_TEST_CMD == ReqCmd)
        {
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_SET); /*IGN-I-HL上电*/
        }
        EH_test.Ehbl_resp.sig.CMD = RspCmd;
        EH_test.Test_Fixture.sig.CMD = ReqCmd;
        EH_test.Test_Fixture.sig.DATA = Req_data;
        EH_test.E_flag.EHBL_send_data_only = true;
        RTE_EHBL_UART_TRANSMIT(EH_test.Test_Fixture.sig.CMD, EH_test.Test_Fixture.sig.DATA); /*串口发送通用请求*/
        EH_test.Sflag = OK_SENT_OR_RECEIVED;                                                 /*发送标志位置位*/
        EH_test.Rflag = NO_SENT_OR_RECEIVED;                                                 /*写入各阶段串口接受成功标志*/
        Record_send_time = RTE_GET_TIMER();                                                  /*记录发送开始时间*/
    }
    /*串口接受到回复或者超时进入*/
    else if (OK_SENT_OR_RECEIVED == EH_test.Rflag || RTE_TIMEOUT_JUDGMENT(Record_send_time, LOCK_ACCEPT_MAX_DELMS))
    {
        /*接受到回复*/
        if (OK_SENT_OR_RECEIVED == EH_test.Rflag)
        {
            /*判断本次请求是否成功*/
            result = Version_number_detection(RspCmd, Rsp_data_ok);
        }
        else
        { /*超时*/
            result = TEST_FAIL;
        }
        EH_test.E_flag.EHBL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: EHBL闭锁标定测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_Lock_test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    switch (EH_test.E_flag.L_stage)
    {
    case LOCK_OR_UNLOCK_STAGE: /*闭锁阶段*/
        result = EHBL_Req_Unlock(LOCK_TEST_CMD, EHBL_LOCK_REQUEST_DATA, IS_LOCK);
        if (TEST_OK == result)
        {
            result = TEST_WAIT;
            /*闭锁测试通过，开始标定*/
            EH_test.E_flag.L_stage = CALIBRATE_STAGE;
        }
        break;
    case CALIBRATE_STAGE: /*标定阶段*/
        result = EHBL_universal_Req_Rsp(CALIBRATION_TEST_CMD, CALIBRATION_RSP_CMD, EHBL_REQUEST_DATA, EHBL_RSP_DATA_OK);
        break;
#if 0
        if (TEST_OK == result)
        {
            result = TEST_WAIT;
            /*标定成功，恢复为闭锁阶段*/
            EH_test.E_flag.L_stage = QUERY_STAGE;
        }
        break;
    case QUERY_STAGE:    
        result = EHBL_universal_Req_Rsp(QUERY_CMD, QUERY_CMD, EHBL_REQUEST_DATA, QUERY_UNLOCK_DATA);
        break;
#endif

    default:
        break;
    }
    return result;
}

/*
 * 函数介绍: EHBL解锁标定测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_UnLock_test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    switch (EH_test.E_flag.UL_stage)
    {
    case LOCK_OR_UNLOCK_STAGE: /*解锁阶段*/
        result = EHBL_Req_Unlock(UNLOCK_TEST_CMD, EHBL_UNLOCK_REQUEST_DATA, IS_UNLOCK);
        if (TEST_OK == result)
        {
            result = TEST_WAIT;
            /*解锁测试通过，开始标定*/
            EH_test.E_flag.UL_stage = CALIBRATE_STAGE;
        }
        break;
    case CALIBRATE_STAGE: /*标定阶段*/
        result = EHBL_universal_Req_Rsp(UN_CALIBRATION_TEST_CMD, UN_CALIBRATION_RSP_CMD, EHBL_REQUEST_DATA, EHBL_RSP_DATA_OK);
        break;
#if 0
        if (TEST_OK == result)
        {
            result = TEST_WAIT;
            /*标定成功，恢复为闭锁阶段*/
            EH_test.E_flag.UL_stage = QUERY_STAGE;
        }
        break;
    case QUERY_STAGE:    
        result = EHBL_universal_Req_Rsp(QUERY_CMD, QUERY_CMD, EHBL_REQUEST_DATA, QUERY_LOCK_DATA);
        break;
#endif
    default:
        break;
    }
    return result;
}

/*
 * 函数介绍: 在LCD上显示阶段结果
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void EHBL_Stage_result_LCDshow(Rt_result result, EHBL_stage stage)
{
    if (TEST_WAIT == result)
    {
        return;
    }
    switch (stage)
    {
    case COMMUNICATION_TEST:
        RTE_UART7_LCD_SHOW(EHBL_TEST, SERIAL_COMMUNICATION, result);
        break;
    case UNLOCK_TEST:
        RTE_UART7_LCD_SHOW(EHBL_TEST, UNLOCK_TEST_STATE, result);
        break;
    case INPUT_TEST:
        RTE_UART7_LCD_SHOW(EHBL_TEST, PRODUCT_INPUT_TEST, result);
        break;
    case LOCK_TEST:
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_TEST_STATE, result);
        break;
    case PROHIBIT_LOCK_TEST:
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_DISABLE_STATE, result);
        break;
    case EHBL_INIT:
        // 在初始化阶段显示解锁成功或失败的信息
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_INIT_UNLOCK, result);
        break;
    case EHBL_DURING_TEST:
        // 在测试进行中显示测试成功或失败的信息
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_SUCCESS_OR_FAILURE, result);
        break;
    case EHBL_QUIT_EOL:
        // 在结束循环模块时显示退出信息
        if (true == Rt_eol_flag())
        {
            RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_EHBL_QUIT_EOL, result);
        }
        break;
    default:
        break;
    }
}

/*
 * 函数介绍: 阶段结果判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void Stage_result_judgment(Rt_result result, EHBL_stage E_st)
{
    E_st += 1;
    EHBL_Stage_result_LCDshow(result, EH_test.E_st);
    if (TEST_OK == result) /*该阶段通讯测试通过*/
    {
        EH_test.e_sta[EH_test.E_st] = result;
        /*修改EHBL的测试阶段为下一个阶段*/
        Modify_EHBL_testing_phase(E_st);
        Whether_test_EOL();
    }
    else if (TEST_FAIL == result)
    {
        EH_test.e_sta[EH_test.E_st] = result;
        /*修改EHBL的测试阶段为下一个阶段*/
        Modify_EHBL_testing_phase(E_st);
        Whether_test_EOL();
    }
    else
    {
    }
}

/*
 * 函数介绍: EHBL禁止上锁测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_No_Lock_Test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    uint8_t i = 0;
    if (0 == EH_test.E_flag.Unlock_first) /*先复位产品为解锁状态*/
    {
        result = EHBL_Req_Unlock(UNLOCK_TEST_CMD, EHBL_UNLOCK_REQUEST_DATA, IS_UNLOCK);
        if (TEST_WAIT != result)
        {
            EH_test.E_flag.Unlock_first = 1;
            result = TEST_WAIT;
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_SET); /*IGN-I-HL上电*/
        }
    }
    else if (1 == EH_test.E_flag.Unlock_first)
    {
        result = EHBL_Req_Unlock(LOCK_TEST_CMD, EHBL_LOCK_REQUEST_DATA, IS_UNLOCK);
        if (false == EH_test.E_flag.EHBL_send_data_only)
        {
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET); /*IGN-I-HL下电*/
            EH_test.E_flag.EHBL_send_data_only = true;
        }
        if (TEST_OK == result)
        {
            /*未上锁，测试通过*/
            EH_test.E_flag.EHBL_send_data_only = false;
            EH_test.E_flag.Unlock_first = 0;
#if 1
            for (i = 0; i < PROHIBIT_LOCK_TEST; i++)
            {
                result |= EH_test.e_sta[i];
            }
            result |= EH_test.EHBL_ver_comp;
            if (TEST_FAIL == result)
            {
                EH_test.EHBL_results = TEST_OK;
            }
#endif
        }
        else if (TEST_FAIL == result)
        {
            /*上锁，测试失败*/
            EH_test.E_flag.EHBL_send_data_only = false;
            EH_test.E_flag.Unlock_first = 0;
            EH_test.EHBL_results = TEST_OK;
        }
    }

    return result;
}

/**
 * @brief 退出EOL测试的函数
 *
 * 该函数用于在进行EOL测试过程中，如果测试状态为OK，则发起退出EOL测试的请求，并等待响应。
 * 根据收到的响应，更新测试结果并返回。
 *
 * @return Rt_result 函数操作的结果状态。可能的返回值包括：
 *                  - TEST_WAIT: 等待测试状态（初始化值和某些条件下的返回值）；
 *                  - TEST_FAIL: 测试失败；
 *                  - 其他值: 依据EHBL_universal_Req_Rsp函数的返回值而定，表示特定的测试结果。
 */
Rt_result EHBL_quit_eol(void)
{
    Rt_result result = TEST_WAIT; /* 初始化返回值为等待测试状态 */
    if (true == Rt_eol_flag())
    {
        /* 检查当前EOL测试状态是否为OK，如果是，则发送退出EOL测试的请求 */
        if (TEST_OK == EH_test.EHBL_Eol)
        {
            /* 调用通用的请求响应处理函数，发送退出EOL测试的请求并等待响应 */
            result = EHBL_universal_Req_Rsp(EHBL_QUIT_EOL_CMD, EHBL_QUIT_EOL_CMD, EHBL_REQUEST_DATA, EHBL_RSP_DATA_OK);
        }
        else
        {
            /* 如果当前EOL测试状态不为OK，则直接返回测试失败 */
            result = TEST_FAIL;
        }
    }
    else
    {
        result = TEST_OK;/*点检模式*/
    }

    /* 如果返回值不为等待测试状态，更新EOL测试结果为OK */
    if (TEST_WAIT != result)
    {
        EH_test.EHBL_results = TEST_OK;
        HAL_Delay(50);
    }

    return result; /* 返回操作结果 */
}
#if 1
/**
 * @brief 该函数用于判断是否进行EOL测试。
 *
 * 该函数遍历检查EH_test结构体中的e_sta数组元素，并根据这些元素的值更新Rt_result类型的result变量。
 * 最后，根据result的值设置EH_test.EHBL_Eol的值，并返回result。
 *
 * @param 无
 * @return void 返回的result值反映了EOL测试的整体结果。
 */
void Whether_test_EOL(void)
{
    uint8_t i = 0;
    Rt_result result = TEST_OK; /* 初始化测试结果为通过 */
    if (EHBL_QUIT_EOL != EH_test.E_st)
    {
        return;
    }

    /* 遍历检查所有e_sta元素，如果有任何一项失败，则result总体结果为失败 */
    for (i = 0; i < EHBL_QUIT_EOL; i++)
    {
        result |= EH_test.e_sta[i];
    }
    result |= EH_test.EHBL_ver_comp;
    /* 根据result的值决定是否进行EOL测试 */
    if (TEST_OK == result) /* 所有检查项都通过 */
    {
        EH_test.EHBL_Eol = TEST_OK;
    }
    else if (TEST_FAIL == result) /* 存在检查项未通过 */
    {
        EH_test.EHBL_Eol = TEST_FAIL;
    }
}
#endif
/*
 * 函数介绍: EHBL测试结果展示
 * 参数:
 * 返回值: {*}
 * 备注:
 * 11.若所有测试项结果OK，测试合格指示绿灯亮，蜂鸣器响1声，
 * LCD屏显示测试合格，并向打标机发送打标信号
 * 反之，测试不合格指示红灯亮，蜂鸣器响3声，
 * LCD屏显示测试不合格。
 * （注： 不合格后进入下一个产品测试时需按一下不良次品盒的开关）
 */
Rt_result EHBL_test_results(void)
{
    uint8_t i = 0;
    Rt_result result = TEST_WAIT; /*测试结果值*/
    /*判断测试流程是否走完*/
    if (TEST_OK == EH_test.EHBL_results)
    {
        result = TEST_OK;
        EH_test.EHBL_results = TEST_WAIT; /*置回标志*/
        for (i = 0; i < EHBL_MAX; i++)
        {
            result |= EH_test.e_sta[i];
        }
        result |= EH_test.EHBL_ver_comp;
    }

    if (TEST_OK == result) /*方向锁测试成功*/
    {
        RTE_UART7_LCD_SHOW(EHBL_TEST, TEST_RESULT, result);
        // RTE_GPIO_PIN_SET_LEVEL(GPIOE,Output11_O_PE13_Pin,GPIO_PIN_SET);/*打标机打标*/
    }
    else if (TEST_FAIL == result) /*方向锁测试失败*/
    {
        RTE_UART7_LCD_SHOW(EHBL_TEST, TEST_RESULT, result);
        Modify_EHBL_testing_phase(EHBL_MAX);
    }
    return result;
}

/*
 * 函数介绍: EHBL功能测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result EHBL_functional_test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    if (EHBL_MAX > EH_test.E_st)
    {
        result = Ehbl_List[EH_test.E_st].EHBL_test();
    }
    Stage_result_judgment(result, EH_test.E_st);
    result = EHBL_test_results();
    return result;
}
